diff --git a/frac/processor/search.go b/frac/processor/search.go
index c4836c3e..d7fe6e0a 100644
--- a/frac/processor/search.go
+++ b/frac/processor/search.go
@@ -44,26 +44,18 @@ type searchIndex interface {
 	GetSkipLIDs(minLID, maxLID uint32, reverse bool) (node.Node, bool, error)
 }
 
-type LIDsIter interface {
-	LIDs(out []node.LID) []node.LID
-	Len() int
-}
-
 type searchBuffers struct {
-	lids lidsBuf
+	lids []node.LID
 	mids []seq.MID
 	rids []seq.RID
 }
 
 var searchBuffersPool = sync.Pool{
 	New: func() any {
-		lidsBuf := lidsBuf{
-			lids: make([]node.LID, 0, consts.LIDBlockCap),
-		}
 		return &searchBuffers{
 			// Currently, we drain up to 4k lids from eval tree, but with proper batching enabled
 			// we can get as much as whole LID block can have (currently, 64k lids)
-			lids: lidsBuf,
+			lids: make([]node.LID, 0, consts.LIDBlockCap),
 			mids: make([]seq.MID, 0, consts.LIDBlockCap),
 			rids: make([]seq.RID, 0, consts.LIDBlockCap),
 		}
@@ -142,30 +134,8 @@ func IndexSearch(
 		m.Stop()
 	}
 
-	var evalTreeIter func(need int, out lidsBuf) LIDsIter
-	batchNode, ok := tryConvertToBatchedTree(evalTree)
-
-	if ok {
-		evalTreeIter = func(need int, _ lidsBuf) LIDsIter {
-			// batched flow: juts get a batch and return
-			return batchNode.NextBatch()
-		}
-	} else {
-		evalTreeIter = func(need int, buf lidsBuf) LIDsIter {
-			// iterator flow: buffer LIDs one by one and return a batch
-			for i := 0; i < need; i++ {
-				lid := evalTree.Next()
-				if lid.IsNull() {
-					break
-				}
-				buf = buf.append(lid)
-			}
-			return buf
-		}
-	}
-
 	m = sw.Start("iterate_eval_tree")
-	total, ids, histMap, aggs, err := iterateEvalTree(ctx, params, index, evalTreeIter, aggSupplier, sw)
+	total, ids, histMap, aggs, err := iterateEvalTree(ctx, params, index, evalTree, aggSupplier, sw)
 	m.Stop()
 
 	if err != nil {
@@ -207,11 +177,36 @@ func IndexSearch(
 	return qpr, nil
 }
 
+func batcher(evalTree node.Node, buf []node.LID) func(need int) []node.LID {
+	if batchNode, ok := tryConvertToBatchedTree(evalTree); ok {
+		return func(need int) []node.LID {
+			buf = batchNode.NextBatch().LIDs(buf[:0])
+			if len(buf) > need {
+				buf = buf[:need]
+			}
+			return buf
+		}
+	}
+
+	return func(need int) []node.LID {
+		// iterator flow: buffer LIDs one by one and return a batch
+		buf = buf[:0]
+		for range min(maxLidsToDrain, need) {
+			lid := evalTree.Next()
+			if lid.IsNull() {
+				break
+			}
+			buf = append(buf, lid)
+		}
+		return buf
+	}
+}
+
 func iterateEvalTree(
 	ctx context.Context,
 	params SearchParams,
 	idsIndex idsIndex,
-	evalTree func(need int, buf lidsBuf) LIDsIter,
+	evalTree node.Node,
 	aggSupplier func() ([]Aggregator, error),
 	sw *stopwatch.Stopwatch,
 ) (int, seq.IDSources, HistMap, []Aggregator, error) {
@@ -233,7 +228,8 @@ func iterateEvalTree(
 	defer searchBuffersPool.Put(buffers)
 	mids := buffers.mids
 	rids := buffers.rids
-	lidsBuffer := buffers.lids
+
+	batchedEvalTree := batcher(evalTree, buffers.lids)
 
 	timerEval := sw.Timer("eval_tree_next")
 	timerMID := sw.Timer("get_mid")
@@ -256,19 +252,15 @@ func iterateEvalTree(
 		if needScanAllRange {
 			needLids = math.MaxUint32
 		}
-		// limit how much we drain from eval tree for one-by-one flow. ignored for batched flow
-		needLids = min(needLids, maxLidsToDrain)
 
 		timerEval.Start()
-		lidBatch := evalTree(needLids, lidsBuffer)
+		lidsSlice := batchedEvalTree(needLids)
 		timerEval.Stop()
 
-		if lidBatch.Len() == 0 {
+		if len(lidsSlice) == 0 {
 			break
 		}
 
-		lidsSlice := lidBatch.LIDs(lidsBuffer.lids)
-
 		needMids := min(params.Limit-len(ids), len(lidsSlice))
 		if hasHist {
 			// need to fetch mids for all lids for hist
@@ -377,26 +369,6 @@ func filterOutOfRangeMIDs(params SearchParams, mids []seq.MID, lidsSlice []node.
 	return mids, lidsSlice
 }
 
-// lidsBuf maintains node.LID in slice as is (append order).
-// Used to drain batches of LIDs when eval tree doesn't support batching.
-type lidsBuf struct {
-	lids []node.LID
-}
-
-func (b lidsBuf) append(x node.LID) lidsBuf {
-	return lidsBuf{
-		lids: append(b.lids, x),
-	}
-}
-
-func (b lidsBuf) Len() int {
-	return len(b.lids)
-}
-
-func (b lidsBuf) LIDs(_ []node.LID) []node.LID {
-	return b.lids
-}
-
 func tryConvertToBatchedTree(evalTree node.Node) (node.BatchedNode, bool) {
 	switch it := evalTree.(type) {
 	case *lids.IteratorDesc: